const { 
    getCarousels, 
    getCarouselById, 
    getCarouselImage 
} = require('../models/Carousel');
const multer = require('multer');
const path = require('path');
const db = require('../config/db');
const logger = require('../utils/logger');

// 内存存储，用于处理图片上传
const storage = multer.memoryStorage();
const upload = multer({ 
    storage: storage,
    limits: {
        fileSize: 5 * 1024 * 1024, // 限制5MB
    },
    fileFilter: (req, file, cb) => {
        console.log('[轮播图] 文件上传过滤:', {
            originalname: file.originalname,
            mimetype: file.mimetype,
            size: file.size
        });
        
        // 只允许图片类型
        const filetypes = /jpeg|jpg|png|gif|webp/;
        const mimetype = filetypes.test(file.mimetype);
        const extname = filetypes.test(path.extname(file.originalname).toLowerCase());
        
        if (mimetype && extname) {
            console.log('[轮播图] 文件类型验证通过');
            return cb(null, true);
        }
        
        console.error('[轮播图] 文件类型不支持');
        cb(new Error('只允许上传jpg、jpeg、png、gif和webp格式的图片!'));
    }
});

/**
 * 获取所有轮播图
 */
const getAllCarousels = async (req, res) => {
    console.log('[轮播图] 开始获取所有轮播图');
    try {
        // 获取轮播图列表，包含image_blob字段
        const carousels = await getCarousels(false);
        console.log('[轮播图] 成功获取轮播图列表:', {
            count: carousels.length,
            ids: carousels.map(c => c.id)
        });
        
        // 转换结果，添加图片访问URL
        const result = carousels.map(carousel => {
            // 如果有image_blob，使用动态生成的URL
            if (carousel.image_blob) {
                return {
                    ...carousel,
                    image_url: `/carousels/${carousel.id}/image`  // 移除/api前缀
                };
            }
            // 否则保持原有的image_url
            return carousel;
        });
        
        res.json({
            code: 200,
            data: result
        });
    } catch (error) {
        console.error('[轮播图] 获取列表失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取轮播图列表失败'
        });
    }
};

/**
 * 获取单个轮播图详情
 */
const getCarouselDetail = async (req, res) => {
    try {
        const { id } = req.params;
        console.log(`[轮播图] 获取详情, ID: ${id}`);
        
        const carousel = await getCarouselById(id);
        
        if (!carousel) {
            console.error(`[轮播图] 未找到ID为 ${id} 的轮播图`);
            return res.status(404).json({
                code: 404,
                message: '轮播图不存在'
            });
        }
        
        // 如果有image_blob，保留它用于编辑页面显示
        if (carousel.image_blob && typeof carousel.image_blob === 'string' && 
            carousel.image_blob.startsWith('data:image')) {
            // 如果是base64格式，直接使用
            console.log(`[轮播图] 详情包含base64图片数据`);
        } else {
            // 如果不是base64或没有image_blob，设置图片URL
            console.log(`[轮播图] 设置图片URL`);
            carousel.image_url = carousel.image_url || `/api/carousels/${carousel.id}/image`;
            // 移除可能的二进制数据以减少响应大小
        delete carousel.image_data;
        }
        
        console.log(`[轮播图] 获取详情成功, ID: ${id}`);
        res.json({
            code: 200,
            data: carousel
        });
    } catch (error) {
        console.error('[轮播图] 获取详情失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取轮播图详情失败'
        });
    }
};

/**
 * 获取轮播图图片
 */
const getImage = async (req, res) => {
    try {
        const { id } = req.params;
        console.log('[轮播图] 开始获取图片:', { id });
        
        const imageData = await getCarouselImage(id);
        console.log('[轮播图] 获取图片数据:', { 
            id,
            hasData: !!imageData,
            hasBlob: imageData && !!imageData.image_blob,
            mimeType: imageData?.mime_type
        });
        
        if (!imageData || !imageData.image_blob) {
            console.error('[轮播图] 图片数据不存在:', { id });
            return res.status(404).json({
                code: 404,
                message: '图片不存在'
            });
        }
        
        // 设置正确的Content-Type
        res.setHeader('Content-Type', imageData.mime_type || 'image/jpeg');
        // 设置文件名
        if (imageData.file_name) {
            res.setHeader('Content-Disposition', `inline; filename="${encodeURIComponent(imageData.file_name)}"`);
        }
        
        // 如果image_blob是Base64字符串，需要解码
        if (typeof imageData.image_blob === 'string' && imageData.image_blob.startsWith('data:')) {
            console.log('[轮播图] 处理Base64图片数据');
            const base64Data = imageData.image_blob.split(';base64,').pop();
            const binaryData = Buffer.from(base64Data, 'base64');
            res.send(binaryData);
        } else {
            // 直接发送二进制数据
            console.log('[轮播图] 发送二进制图片数据');
            res.send(imageData.image_blob);
        }
        
        console.log('[轮播图] 图片发送成功:', { id });
    } catch (error) {
        console.error('[轮播图] 获取图片失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取轮播图图片失败'
        });
    }
};

/**
 * 获取轮播图列表
 */
const getCarouselList = async (req, res) => {
    try {
        // 使用模型方法获取轮播图列表，不包含图片数据
        const carousels = await getCarousels(false);
        
        // 转换结果，添加图片访问URL
        const result = carousels.map(carousel => {
            // 如果有image_blob，使用动态生成的URL
            if (carousel.image_blob) {
                return {
                    ...carousel,
                    image_url: `/api/carousels/${carousel.id}/image`
                };
            }
            // 否则保持原有的image_url
            return carousel;
        });
        
        res.json({
            code: 200,
            message: '获取成功',
            data: result
        });
    } catch (error) {
        console.error('[轮播图] 获取列表失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取轮播图列表失败'
        });
    }
};

/**
 * 创建轮播图
 */
const createCarousel = async (req, res) => {
    try {
        logger.info('[轮播图] 开始创建轮播图');
        const { title, store_id, sort_order, image_data } = req.body;
        
        // 验证必要字段
        if (!title || !image_data) {
            logger.warn('[轮播图] 创建失败: 标题或图片数据为空');
            return res.status(400).json({ 
                message: '标题和图片数据不能为空',
                code: 400 
            });
        }

        // 验证Base64数据
        if (!image_data.match(/^data:image\/(png|jpeg|jpg|gif);base64,/)) {
            logger.warn('[轮播图] 创建失败: 无效的图片格式');
            return res.status(400).json({ 
                message: '无效的图片格式',
                code: 400 
            });
        }

        // 从base64数据中提取MIME类型
        const mimeType = image_data.match(/^data:([^;]+);base64,/)[1];
        
        // 生成随机文件名
        const fileName = `carousel_${Date.now()}.${mimeType.split('/')[1]}`;
        
        // 计算大致文件大小
        const base64Data = image_data.split(',')[1];
        const fileSize = Math.round(base64Data.length * 3 / 4);

        const sql = `
            INSERT INTO carousels (title, store_id, sort_order, image_blob, mime_type, file_name, file_size)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        `;
        
        const [result] = await db.execute(sql, [
            title,
            store_id || null,
            sort_order || 0,
            image_data,
            mimeType,
            fileName,
            fileSize
        ]);

        logger.info(`[轮播图] 创建成功，ID: ${result.insertId}`);
        
        res.status(201).json({
            code: 201,
            message: '轮播图创建成功',
            data: {
                id: result.insertId,
                image_url: `/api/carousels/${result.insertId}/image`
            }
        });
    } catch (error) {
        logger.error('[轮播图] 创建失败:', error);
        res.status(500).json({
            code: 500,
            message: '创建轮播图失败'
        });
    }
};

/**
 * 更新轮播图
 */
const updateCarousel = async (req, res) => {
    try {
        const { id } = req.params;
        logger.info(`[轮播图] 开始更新轮播图, ID: ${id}`);
        
        const { title, store_id, sort_order, image_data } = req.body;
        
        // 验证ID
        if (!id) {
            logger.warn('[轮播图] 更新失败: 缺少ID');
            return res.status(400).json({
                code: 400,
                message: '缺少轮播图ID'
            });
        }
        
        // 检查轮播图是否存在
        const carousel = await getCarouselById(id);
        if (!carousel) {
            logger.warn(`[轮播图] 更新失败: ID ${id} 不存在`);
            return res.status(404).json({
                code: 404,
                message: '轮播图不存在'
            });
        }
        
        // 准备更新数据
        const updateData = {};
        
        if (title !== undefined) {
            updateData.title = title;
        }
        
        if (store_id !== undefined) {
            updateData.store_id = store_id || null;
        }
        
        if (sort_order !== undefined) {
            updateData.sort_order = sort_order;
        }
        
        // 处理图片数据
        if (image_data) {
            // 验证Base64数据
            if (!image_data.match(/^data:image\/(png|jpeg|jpg|gif);base64,/)) {
                logger.warn('[轮播图] 更新失败: 无效的图片格式');
                return res.status(400).json({
                    code: 400,
                    message: '无效的图片格式'
                });
            }
            
            // 从base64数据中提取MIME类型
            const mimeType = image_data.match(/^data:([^;]+);base64,/)[1];
            
            // 生成随机文件名
            const fileName = `carousel_${Date.now()}.${mimeType.split('/')[1]}`;
            
            // 计算大致文件大小
            const base64Data = image_data.split(',')[1];
            const fileSize = Math.round(base64Data.length * 3 / 4);
            
            updateData.image_blob = image_data;
            updateData.mime_type = mimeType;
            updateData.file_name = fileName;
            updateData.file_size = fileSize;
        }
        
        // 执行更新
        if (Object.keys(updateData).length === 0) {
            logger.warn('[轮播图] 更新失败: 没有提供需要更新的数据');
            return res.status(400).json({
                code: 400,
                message: '没有提供需要更新的数据'
            });
        }
        
        // 构建SQL语句和参数
        const fields = [];
        const values = [];
        
        for (const [key, value] of Object.entries(updateData)) {
            fields.push(`${key} = ?`);
            values.push(value);
        }
        
        // 添加更新时间
        fields.push('updated_at = NOW()');
        
        // 添加WHERE条件的ID
        values.push(id);
        
        const sql = `UPDATE carousels SET ${fields.join(', ')} WHERE id = ?`;
        
        await db.execute(sql, values);
        
        logger.info(`[轮播图] 更新成功, ID: ${id}`);
        res.json({
            code: 200,
            message: '轮播图更新成功',
            data: {
                id: parseInt(id),
                image_url: `/api/carousels/${id}/image`
            }
        });
    } catch (error) {
        logger.error('[轮播图] 更新失败:', error);
        res.status(500).json({
            code: 500,
            message: '更新轮播图失败'
        });
    }
};

/**
 * 更新轮播图状态
 */
const updateCarouselStatus = async (req, res) => {
    console.log('[轮播图] 开始更新状态:', {
        id: req.params.id,
        status: req.body.status
    });
    try {
        const { id } = req.params;
        const { status } = req.body;

        if (!['active', 'inactive'].includes(status)) {
            console.error('[轮播图] 状态更新失败: 无效的状态值', { status });
            return res.status(400).json({
                code: 400,
                message: '无效的状态值'
            });
        }

        await db.execute('UPDATE carousels SET status = ? WHERE id = ?', [status, id]);

        console.log('[轮播图] 状态更新成功:', {
            id,
            newStatus: status
        });

        res.json({
            code: 200,
            message: '状态更新成功'
        });
    } catch (error) {
        console.error('[轮播图] 状态更新失败:', error);
        res.status(500).json({
            code: 500,
            message: '更新轮播图状态失败'
        });
    }
};

/**
 * 更新轮播图排序
 */
const updateCarouselOrder = async (req, res) => {
    console.log('[轮播图] 开始更新排序:', req.body);
    try {
        const { orders } = req.body;

        if (!Array.isArray(orders)) {
            console.error('[轮播图] 排序更新失败: 无效的排序数据', { orders });
            return res.status(400).json({
                code: 400,
                message: '无效的排序数据'
            });
        }

        // 使用事务确保排序更新的原子性
        const connection = await db.getConnection();
        await connection.beginTransaction();

        try {
            for (const item of orders) {
                console.log('[轮播图] 更新单项排序:', {
                    id: item.id,
                    sort_order: item.sort_order
                });
                
                await connection.execute(
                    'UPDATE carousels SET sort_order = ? WHERE id = ?',
                    [item.sort_order, item.id]
                );
            }

            await connection.commit();
            console.log('[轮播图] 排序更新成功:', {
                updatedItems: orders.length
            });
            
            res.json({
                code: 200,
                message: '排序更新成功'
            });
        } catch (error) {
            await connection.rollback();
            throw error;
        } finally {
            connection.release();
        }
    } catch (error) {
        console.error('[轮播图] 排序更新失败:', error);
        res.status(500).json({
            code: 500,
            message: '更新轮播图排序失败'
        });
    }
};

/**
 * 删除轮播图
 */
const deleteCarousel = async (req, res) => {
    try {
        const { id } = req.params;
        logger.info(`[轮播图] 开始删除轮播图 ID: ${id}`);

        const sql = 'DELETE FROM carousels WHERE id = ?';
        const [result] = await db.execute(sql, [id]);

        if (result.affectedRows === 0) {
            logger.warn(`[轮播图] 未找到ID为 ${id} 的轮播图`);
            return res.status(404).json({ 
                message: '轮播图不存在',
                code: 404 
            });
        }

        logger.info(`[轮播图] 删除成功，ID: ${id}`);
        res.json({ 
            message: '轮播图删除成功',
            code: 200 
        });
    } catch (error) {
        logger.error('[轮播图] 删除失败:', error);
        res.status(500).json({ 
            message: '删除轮播图失败',
            code: 500 
        });
    }
};

// 导出multer中间件，用于处理文件上传
const uploadCarouselImage = upload.single('image');

// 包装multer中间件，跳过验证错误
const handleFileUpload = (req, res, next) => {
    console.log('[轮播图] 开始处理文件上传请求');
    uploadCarouselImage(req, res, (err) => {
        if (err instanceof multer.MulterError) {
            console.error('[轮播图] 文件上传错误:', err);
            return res.status(400).json({
                code: 400,
                message: '文件上传错误: ' + err.message
            });
        } else if (err) {
            console.error('[轮播图] 文件上传失败:', err);
            return res.status(500).json({
                code: 500,
                message: '文件上传失败: ' + err.message
            });
        }
        console.log('[轮播图] 文件上传处理完成');
        next();
    });
};

/**
 * 处理图片上传
 */
const uploadImage = async (req, res) => {
    console.log('[轮播图] 开始处理图片上传');
    try {
        if (!req.file) {
            console.error('[轮播图] 未找到上传的文件');
            return res.status(400).json({
                code: 400,
                message: '请选择要上传的图片'
            });
        }

        console.log('[轮播图] 文件信息:', {
            originalname: req.file.originalname,
            mimetype: req.file.mimetype,
            size: req.file.size
        });

        // 生成临时文件URL
        const imageUrl = `/api/carousels/temp/${Date.now()}-${req.file.originalname}`;
        console.log('[轮播图] 生成临时URL:', imageUrl);
        
        res.json({
            code: 200,
            message: '上传成功',
            data: {
                url: imageUrl
            }
        });
    } catch (error) {
        console.error('[轮播图] 图片上传失败:', error);
        res.status(500).json({
            code: 500,
            message: '图片上传失败'
        });
    }
};

module.exports = { 
    getAllCarousels,
    getCarouselDetail,
    getImage,
    getCarouselList,
    createCarousel,
    updateCarousel,
    deleteCarousel,
    updateCarouselStatus,
    updateCarouselOrder,
    handleFileUpload,
    uploadImage
};